/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#pragma once

#include "节点/节点.h"

#include "节点/插座/C_数值插座.h"
#include "节点/插座/C_单值矢量插座.h"
#include "节点/插座/list/list数值插座.h"




class C_变量引用节点 : public C_节点基类 {

public:
	C_变量引用节点(S_设备环境& ctx);
	~C_变量引用节点();

	S_Props	m_引用;

	//void	f_读取(FILE* f);
	//void	f_写入(FILE* f);

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
};

C_节点基类* f_node_创建变量引用节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载变量引用节点(S_设备环境& ctx, FILE* f);
void		f_node_保存变量引用节点(C_节点基类* n, FILE* f);



class C_I8变量节点 : public C_节点基类 {

public:
	C_I8变量节点(S_设备环境& ctx);
	~C_I8变量节点();

	S_Props	m_随机方式;
	S_Props	m_初始值;
	
	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	void	f_Copy(const C_节点基类* node);
};

C_节点基类* f_node_创建I8变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载I8变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存I8变量节点(C_节点基类* n, FILE* f);



class C_单值浮点变量节点 : public C_节点基类 {
	
public:
	C_单值浮点变量节点(S_设备环境& ctx);
	~C_单值浮点变量节点();

	S_Props	m_位数;
	S_Props	m_是否随机;
	S_Props	m_值;
	S_Props	m_常用量;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_Copy(const C_节点基类* node);
};

C_节点基类* f_node_创建单值浮点变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载单值浮点变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存单值浮点变量节点(C_节点基类* n, FILE* f);




class C_单值整数变量节点 : public C_节点基类 {

public:
	C_单值整数变量节点(S_设备环境& ctx);
	~C_单值整数变量节点();

	S_Props	m_位数;
	S_Props	m_是否随机;
	S_Props	m_值;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_Copy(const C_节点基类* node);
};

C_节点基类* f_node_创建单值整数变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载单值整数变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存单值整数变量节点(C_节点基类* n, FILE* f);



class C_无符号整数变量节点 : public C_节点基类 {

public:
	C_无符号整数变量节点(S_设备环境& ctx);
	~C_无符号整数变量节点();

	S_Props	m_位数;
	S_Props	m_是否随机;
	S_Props	m_值;

	//S_Props	m_使用标志位;
	S_Props	m_标志位;

	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	void	f_Copy(const C_节点基类* node);
};

C_节点基类* f_node_创建无符号整数变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载无符号整数变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存无符号整数变量节点(C_节点基类* n, FILE* f);



class C_I8数组变量节点 : public C_节点基类 {
	
public:
	C_I8数组变量节点(S_设备环境& ctx);
	~C_I8数组变量节点();

	S_Props		m_随机方式;
	//S_F32Array*	m_Value;
	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

};

C_节点基类* f_node_创建I8数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载I8数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存I8数组变量节点(C_节点基类* n, FILE* f);



class C_F32数组变量节点 : public C_节点基类 {

public:
	C_F32数组变量节点(S_设备环境& ctx);
	~C_F32数组变量节点();

	S_Props		m_位数;
	S_Props		m_随机方式;
	//S_F32Array*	m_Value;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
};

C_节点基类* f_node_创建浮点数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载浮点数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存浮点数组变量节点(C_节点基类* n, FILE* f);




class C_I32数组变量节点 : public C_节点基类 {
public:
	C_I32数组变量节点(S_设备环境& ctx);
	~C_I32数组变量节点();

	S_Props		m_位数;
	S_Props		m_随机方式;
	S_Props		m_值;

	bool	f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建区间数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载区间数组变量节点(S_设备环境& ctx, FILE* f);
void f_node_保存区间数组变量节点(C_节点基类* n, FILE* f);



class C_UI32数组变量节点 : public C_节点基类 {
public:
	C_UI32数组变量节点(S_设备环境& ctx);
	~C_UI32数组变量节点();

	//S_Props		m_位数;
	S_Props		m_随机方式;
	S_Props		m_值;

	bool	f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
	void	f_Copy(const C_节点基类* node);
};

C_节点基类* f_node_创建UI32数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载UI32数组变量节点(S_设备环境& ctx, FILE* f);
void        f_node_保存UI32数组变量节点(C_节点基类* n, FILE* f);



class C_vec2变量节点 : public C_节点基类 {

public:
	C_vec2变量节点(S_设备环境& ctx);
	~C_vec2变量节点();

	S_Props	m_Value;
	S_Props	m_是否随机;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建vec2变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载vec2变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存vec2变量节点(C_节点基类* n, FILE* f);





class C_vec3变量节点 : public C_节点基类 {

public:
	C_vec3变量节点(S_设备环境& ctx);
	~C_vec3变量节点();

	S_Props	m_Value;
	S_Props	m_是否随机;
	//S_Props	m_值;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建vec3变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载vec3变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存vec3变量节点(C_节点基类* n, FILE* f);



class C_ivec3变量节点 : public C_节点基类 {

public:
	C_ivec3变量节点(S_设备环境& ctx);
	~C_ivec3变量节点();

	S_Props	m_Value;
	S_Props	m_是否随机;

	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建ivec3变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载ivec3变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存ivec3变量节点(C_节点基类* n, FILE* f);



class C_vec2数组变量节点 : public C_节点基类 {

public:
	C_vec2数组变量节点(S_设备环境& ctx);
	~C_vec2数组变量节点();

	S_Props	m_是否为数组;
	S_Props	m_是否随机;

	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
};

C_节点基类* f_node_创建vec2数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载vec2数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存vec2数组变量节点(C_节点基类* n, FILE* f);



class C_ivec2数组变量节点 : public C_节点基类 {

public:
	C_ivec2数组变量节点(S_设备环境& ctx);
	~C_ivec2数组变量节点();

	//S_Props	m_是否为数组;
	S_Props	m_填充方式;

	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
};

C_节点基类* f_node_创建ivec2数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载ivec2数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存ivec2数组变量节点(C_节点基类* n, FILE* f);



class C_vec3数组变量节点 : public C_节点基类 {

public:
	C_vec3数组变量节点(S_设备环境& ctx);
	~C_vec3数组变量节点();

	S_Props	m_是否随机;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
	std::string	DEF_节点编译函数;
};

C_节点基类* f_node_创建vec3数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载vec3数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存vec3数组变量节点(C_节点基类* n, FILE* f);




class C_ivec3数组变量节点 : public C_节点基类 {

public:
	C_ivec3数组变量节点(S_设备环境& ctx);
	~C_ivec3数组变量节点();

	S_Props	m_是否随机;
	S_Props	m_是否无符号;

	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

};

C_节点基类* f_node_创建ivec3数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载ivec3数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存ivec3数组变量节点(C_节点基类* n, FILE* f);




class C_多边形成员数组变量节点 : public C_节点基类 {

public:
	C_多边形成员数组变量节点(S_设备环境& ctx);
	~C_多边形成员数组变量节点();

	S_Props	m_成员;
	S_Props	m_维度;

	bool	f_update();
	std::string	DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

};

C_节点基类* f_node_创建多边形成员数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载多边形成员数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存多边形成员数组变量节点(C_节点基类* n, FILE* f);




class C_vec球数组节点 : public C_节点基类 {

public:
	C_vec球数组节点(S_设备环境& ctx);
	~C_vec球数组节点();

	S_Props	m_是否随机;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建vec球数组节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载vec球数组节点(S_设备环境& ctx, FILE* f);
void		f_node_保存vec球数组节点(C_节点基类* n, FILE* f);




class C_矩阵数组变量节点 : public C_节点基类 {

public:
	C_矩阵数组变量节点(S_设备环境& ctx);
	~C_矩阵数组变量节点();

	bool			m_是否取随机数;


	void	f_读取(FILE* f);
	void	f_写入(FILE* f);

	bool	f_update();
};

C_节点基类* f_node_创建矩阵数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载矩阵数组变量节点(S_设备环境& ctx, FILE* f);
void		f_node_保存矩阵数组变量节点(C_节点基类* n, FILE* f);





class C_矩阵构建节点 : public C_节点基类 {
public:
	C_矩阵构建节点(S_设备环境& ctx);
	~C_矩阵构建节点();

	S_Props	m_矩阵类型;
	S_Props	m_轴向;

	S_Props	m_方向;
	S_Props	m_角度;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建矩阵构建节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载矩阵构建节点(S_设备环境& ctx, FILE* f);
void f_node_保存矩阵构建节点(C_节点基类* n, FILE* f);




class C_Vec4数组节点 : public C_节点基类 {
public:
	C_Vec4数组节点(S_设备环境& ctx);
	~C_Vec4数组节点();

	S_Props	m_是否随机;

	bool	f_update();
	std::string DEF_节点编译函数;
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建Vec4数组节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载Vec4数组节点(S_设备环境& ctx, FILE* f);
void        f_node_保存Vec4数组节点(C_节点基类* n, FILE* f);



class C_坐标构建平面节点 : public C_节点基类 {
public:
	C_坐标构建平面节点(S_设备环境& ctx);
	~C_坐标构建平面节点();

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建坐标构建平面节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载坐标构建平面节点(S_设备环境& ctx, FILE* f);
void        f_node_保存坐标构建平面节点(C_节点基类* n, FILE* f);




class C_观察矩阵构建节点 : public C_节点基类 {
public:
	C_观察矩阵构建节点(S_设备环境& ctx);
	~C_观察矩阵构建节点();

	S_Props	m_翻转;

	bool	f_update();
	std::string	f_编译(C_节点基类* rn, std::string& 声明, std::vector<std::string>& 定义, std::string& 释放);
	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建观察矩阵构建节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载观察矩阵构建节点(S_设备环境& ctx, FILE* f);
void f_node_保存观察矩阵构建节点(C_节点基类* n, FILE* f);




class C_线段数据节点 : public C_节点基类 {
public:
	C_线段数据节点(S_设备环境& ctx);
	~C_线段数据节点();

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建线段数据节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载线段数据节点(S_设备环境& ctx, FILE* f);
void f_node_保存线段数据节点(C_节点基类* n, FILE* f);




class C_线段1D数据节点 : public C_节点基类 {
public:
	C_线段1D数据节点(S_设备环境& ctx);
	~C_线段1D数据节点();

	S_Props	m_组合类型;

	bool	f_update();

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建线段1D变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载线段1D数据节点(S_设备环境& ctx, FILE* f);
void f_node_保存线段1D数据节点(C_节点基类* n, FILE* f);





class C_数组变量节点 : public C_节点基类 {
public:
	C_数组变量节点(S_设备环境& ctx);
	~C_数组变量节点();

	S_Props	m_元素类型;

	bool	f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建数组变量节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载数组变量节点(S_设备环境& ctx, FILE* f);
void f_node_保存数组变量节点(C_节点基类* n, FILE* f);




class C_数组添加元素节点 : public C_节点基类 {
public:
	C_数组添加元素节点(S_设备环境& ctx);
	~C_数组添加元素节点();

	S_Props	m_添加方式;

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建数组添加元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载数组添加元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存数组添加元素节点(C_节点基类* n, FILE* f);




class C_取数组属性节点 : public C_节点基类 {
public:
	C_取数组属性节点(S_设备环境& ctx);
	~C_取数组属性节点();

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取数组属性节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取数组属性节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取数组属性节点(C_节点基类* n, FILE* f);



class C_取数组元素节点 : public C_节点基类 {
public:
	C_取数组元素节点(S_设备环境& ctx);
	~C_取数组元素节点();

	S_Props	m_位置索引;

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取数组元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取数组元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取数组元素节点(C_节点基类* n, FILE* f);



class C_取数组头尾元素节点 : public C_节点基类 {
public:
	C_取数组头尾元素节点(S_设备环境& ctx);
	~C_取数组头尾元素节点();

	S_Props	m_位置索引;

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建取末尾数组元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载取末尾数组元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存取末尾数组元素节点(C_节点基类* n, FILE* f);



class C_合并数组元素节点 : public C_节点基类 {
public:
	C_合并数组元素节点(S_设备环境& ctx);
	~C_合并数组元素节点();

	bool		f_update();
	std::string DEF_节点编译函数;
};

C_节点基类* f_node_创建合并数组元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载合并数组元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存合并数组元素节点(C_节点基类* n, FILE* f);



class C_插入数组节点 : public C_节点基类 {
public:
	C_插入数组节点(S_设备环境& ctx);
	~C_插入数组节点();

	bool		f_update();
	std::string DEF_节点编译函数;
};

C_节点基类* f_node_创建插入数组节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载插入数组节点(S_设备环境& ctx, FILE* f);
void		f_node_保存插入数组节点(C_节点基类* n, FILE* f);



class C_删除数组元素节点 : public C_节点基类 {
public:
	C_删除数组元素节点(S_设备环境& ctx);
	~C_删除数组元素节点();

	S_Props	m_位置索引;

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建删除数组元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载删除数组元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存删除数组元素节点(C_节点基类* n, FILE* f);



class C_查找数组元素节点 : public C_节点基类 {
public:
	C_查找数组元素节点(S_设备环境& ctx);
	~C_查找数组元素节点();

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建查找数组元素节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载查找数组元素节点(S_设备环境& ctx, FILE* f);
void		f_node_保存查找数组元素节点(C_节点基类* n, FILE* f);



class C_复制数组节点 : public C_节点基类 {
public:
	C_复制数组节点(S_设备环境& ctx);
	~C_复制数组节点();

	bool		f_update();
	std::string DEF_节点编译函数;
};

C_节点基类* f_node_创建复制数组节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载复制数组节点(S_设备环境& ctx, FILE* f);
void		f_node_保存复制数组节点(C_节点基类* n, FILE* f);



class C_数组元素统计节点 : public C_节点基类 {
public:
	C_数组元素统计节点(S_设备环境& ctx);
	~C_数组元素统计节点();

	S_Props		m_统计类型;

	bool		f_update();
	std::string DEF_节点编译函数;

	void	f_读取(FILE* f);
	void	f_写入(FILE* f);
};

C_节点基类* f_node_创建数组元素统计节点(S_设备环境& ctx, C_节点树* 子节点树);
C_节点基类* f_node_加载数组元素统计节点(S_设备环境& ctx, FILE* f);
void		f_node_保存数组元素统计节点(C_节点基类* n, FILE* f);



